home *** CD-ROM | disk | FTP | other *** search
/ C++ für Kids / C++ for kids.iso / SETUP / CBUILDER / DATA.Z / DBTABLES.HPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-20  |  42.8 KB  |  1,145 lines
  1. //----------------------------------------------------------------------------
  2. // DBTables.hpp - bcbdcc32 generated hdr (DO NOT EDIT) rev: 0
  3. // From: DBTables.pas
  4. //----------------------------------------------------------------------------
  5. #ifndef DBTablesHPP
  6. #define DBTablesHPP
  7. //----------------------------------------------------------------------------
  8. #include <DB.hpp>
  9. #include <Mask.hpp>
  10. #include <Graphics.hpp>
  11. #include <Controls.hpp>
  12. #include <Classes.hpp>
  13. #include <Bde.hpp>
  14. #include <Windows.hpp>
  15. #include <SysUtils.hpp>
  16. #include <System.hpp>
  17. #pragma warn -par
  18. #pragma warn -hid 
  19. #pragma warn -inl
  20.  
  21. namespace Dbtables
  22. {
  23. //-- type declarations -------------------------------------------------------
  24. enum DBTables_1 { ixPrimary, ixUnique, ixDescending, ixCaseInsensitive, ixExpression };
  25.  
  26. typedef Set<DBTables_1, ixPrimary, ixExpression>  TIndexOptions;
  27.  
  28. class __declspec(delphiclass) TIndexDef;
  29. class __declspec(delphiclass) TIndexDefs;
  30. class __declspec(delphiclass) TTable;
  31. class __declspec(delphiclass) TTableDataLink;
  32. class __declspec(pascalimplementation) TTableDataLink : public Db::TDataLink
  33. {
  34.     typedef Db::TDataLink inherited;
  35.     
  36. private:
  37.     TTable* FTable;
  38.     System::AnsiString FFieldNames;
  39.     Classes::TList* FFields;
  40.     void __fastcall SetFieldNames(const System::AnsiString Value);
  41.     
  42. protected:
  43.     virtual void __fastcall ActiveChanged(void);
  44.     virtual void __fastcall CheckBrowseMode(void);
  45.     virtual void __fastcall LayoutChanged(void);
  46.     virtual void __fastcall RecordChanged(Db::TField* Field);
  47.     
  48. public:
  49.     __fastcall TTableDataLink(TTable* Table);
  50.     __fastcall virtual ~TTableDataLink(void);
  51. };
  52.  
  53. enum TTableType { ttDefault, ttParadox, ttDBase, ttASCII };
  54.  
  55. typedef System::AnsiString TIndexName;
  56.  
  57. enum TLockType { ltReadLock, ltWriteLock };
  58.  
  59. enum TBatchMode { batAppend, batUpdate, batAppendUpdate, batDelete, batCopy };
  60.  
  61. class __declspec(pascalimplementation) TTable : public Db::TDBDataSet
  62. {
  63.     typedef Db::TDBDataSet inherited;
  64.     
  65. private:
  66.     TIndexDefs* FIndexDefs;
  67.     TTableDataLink* FDataLink;
  68.     bool FExclusive;
  69.     bool FReadOnly;
  70.     TTableType FTableType;
  71.     bool FFieldsIndex;
  72.     System::AnsiString FTableName;
  73.     System::AnsiString FIndexName;
  74.     Classes::TStrings* FIndexFiles;
  75.     Bde::_hDBIObj *FLookupHandle;
  76.     System::AnsiString FLookupKeyFields;
  77.     Bde::_hDBIObj *FLookupCursor;
  78.     void __fastcall DecodeIndexDesc(const Bde::IDXDesc &IndexDesc,  System::AnsiString &Source,  System::AnsiString &
  79.         Name,  System::AnsiString &Fields, TIndexOptions &Options);
  80.     void __fastcall EncodeFieldDesc(Bde::FLDDesc &FieldDesc, const System::AnsiString Name, Db::TFieldType 
  81.         DataType, Word Size);
  82.     void __fastcall EncodeIndexDesc(Bde::IDXDesc &IndexDesc, const System::AnsiString Name, const System::AnsiString 
  83.         Fields, TIndexOptions Options);
  84.     char * __fastcall GetDriverTypeName(char * Buffer);
  85.     System::AnsiString __fastcall GetIndexFieldNames(void);
  86.     System::AnsiString __fastcall GetIndexName(void);
  87.     void __fastcall GetIndexParams(const System::AnsiString IndexName, bool FieldsIndex,  System::AnsiString &
  88.         IndexedName,  System::AnsiString &IndexTag);
  89.     System::AnsiString __fastcall GetMasterFields(void);
  90.     char * __fastcall GetTableTypeName(void);
  91.     bool __fastcall IsDBaseTable(void);
  92.     void __fastcall MasterChanged(void);
  93.     void __fastcall SetDataSource(Db::TDataSource* Value);
  94.     void __fastcall SetExclusive(bool Value);
  95.     void __fastcall SetIndex(const System::AnsiString Value, bool FieldsIndex);
  96.     void __fastcall SetIndexFieldNames(const System::AnsiString Value);
  97.     void __fastcall SetIndexFiles(Classes::TStrings* Value);
  98.     void __fastcall SetIndexName(const System::AnsiString Value);
  99.     void __fastcall SetMasterFields(const System::AnsiString Value);
  100.     void __fastcall SetReadOnly(bool Value);
  101.     void __fastcall SetTableLock(TLockType LockType, bool Lock);
  102.     void __fastcall SetTableName(const System::AnsiString Value);
  103.     void __fastcall SetTableType(TTableType Value);
  104.     void __fastcall UpdateIndexDefs(void);
  105.     void __fastcall UpdateRange(void);
  106.     
  107. protected:
  108.     virtual Bde::hDBICur __fastcall CreateHandle(void);
  109.     virtual void __fastcall DataEvent(Db::TDataEvent Event, long Info);
  110.     virtual void __fastcall DestroyHandle(void);
  111.     virtual void __fastcall DestroyLookupCursor(void);
  112.     virtual void __fastcall DoOnNewRecord(void);
  113.     virtual bool __fastcall GetCanModify(void);
  114.     virtual Db::TDataSource* __fastcall GetDataSource(void);
  115.     Bde::hDBICur __fastcall GetHandle(const System::AnsiString IndexName, const System::AnsiString IndexTag
  116.         );
  117.     System::AnsiString __fastcall GetLanguageDriverName(void);
  118.     virtual Bde::hDBICur __fastcall GetLookupCursor(const System::AnsiString KeyFields, bool CaseInsensitive
  119.         );
  120.     virtual void __fastcall InitFieldDefs(void);
  121.     bool __fastcall IsProductionIndex(const System::AnsiString IndexName);
  122.     virtual void __fastcall PrepareCursor(void);
  123.     
  124. public:
  125.     __fastcall virtual TTable(Classes::TComponent* AOwner);
  126.     __fastcall virtual ~TTable(void);
  127.     long __fastcall BatchMove(Db::TDataSet* ASource, TBatchMode AMode);
  128.     void __fastcall AddIndex(const System::AnsiString Name, const System::AnsiString Fields, TIndexOptions 
  129.         Options);
  130.     void __fastcall ApplyRange(void);
  131.     void __fastcall CancelRange(void);
  132.     void __fastcall CloseIndexFile(const System::AnsiString IndexFileName);
  133.     void __fastcall CreateTable(void);
  134.     void __fastcall DeleteIndex(const System::AnsiString Name);
  135.     void __fastcall DeleteTable(void);
  136.     void __fastcall EditKey(void);
  137.     void __fastcall EditRangeEnd(void);
  138.     void __fastcall EditRangeStart(void);
  139.     void __fastcall EmptyTable(void);
  140.     bool __fastcall FindKey(const System::TVarRec * KeyValues, const int KeyValues_Size);
  141.     void __fastcall FindNearest(const System::TVarRec * KeyValues, const int KeyValues_Size);
  142.     void __fastcall GetIndexNames(Classes::TStrings* List);
  143.     void __fastcall GotoCurrent(TTable* Table);
  144.     bool __fastcall GotoKey(void);
  145.     void __fastcall GotoNearest(void);
  146.     void __fastcall LockTable(TLockType LockType);
  147.     void __fastcall OpenIndexFile(const System::AnsiString IndexName);
  148.     void __fastcall RenameTable(const System::AnsiString NewTableName);
  149.     void __fastcall SetKey(void);
  150.     void __fastcall SetRange(const System::TVarRec * StartValues, const int StartValues_Size, const System::TVarRec 
  151.         * EndValues, const int EndValues_Size);
  152.     void __fastcall SetRangeEnd(void);
  153.     void __fastcall SetRangeStart(void);
  154.     void __fastcall UnlockTable(TLockType LockType);
  155.     __property TIndexDefs* IndexDefs = {read=FIndexDefs, nodefault};
  156.     __property int IndexFieldCount = {read=GetIndexFieldCount, nodefault};
  157.     __property Db::TField* IndexFields[int Index] = {read=GetIndexField, write=SetIndexField};
  158.     __property bool KeyExclusive = {read=GetKeyExclusive, write=SetKeyExclusive, nodefault};
  159.     __property int KeyFieldCount = {read=GetKeyFieldCount, write=SetKeyFieldCount, nodefault};
  160.     
  161. __published:
  162.     __property bool Exclusive = {read=FExclusive, write=SetExclusive, default=0};
  163.     __property System::AnsiString IndexFieldNames = {read=GetIndexFieldNames, write=SetIndexFieldNames, 
  164.         nodefault};
  165.     __property Classes::TStrings* IndexFiles = {read=FIndexFiles, write=SetIndexFiles, nodefault};
  166.     __property System::AnsiString IndexName = {read=GetIndexName, write=SetIndexName, nodefault};
  167.     __property System::AnsiString MasterFields = {read=GetMasterFields, write=SetMasterFields, nodefault
  168.         };
  169.     __property Db::TDataSource* MasterSource = {read=GetDataSource, write=SetDataSource, nodefault};
  170.     __property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, default=0};
  171.     __property System::AnsiString TableName = {read=FTableName, write=SetTableName, nodefault};
  172.     __property TTableType TableType = {read=FTableType, write=SetTableType, default=0};
  173.     __property UpdateMode ;
  174.     __property UpdateObject ;
  175. };
  176.  
  177. class __declspec(pascalimplementation) TIndexDefs : public System::TObject
  178. {
  179.     typedef System::TObject inherited;
  180.     
  181. private:
  182.     TTable* FTable;
  183.     Classes::TList* FItems;
  184.     bool FUpdated;
  185.     Byte FReserved;
  186.     int __fastcall GetCount(void);
  187.     TIndexDef* __fastcall GetIndexForFields(const System::AnsiString Fields, bool CaseInsensitive);
  188.     TIndexDef* __fastcall GetItem(int Index);
  189.     
  190. public:
  191.     __fastcall TIndexDefs(TTable* Table);
  192.     __fastcall virtual ~TIndexDefs(void);
  193.     void __fastcall Add(const System::AnsiString Name, const System::AnsiString Fields, TIndexOptions Options
  194.         );
  195.     void __fastcall Assign(TIndexDefs* IndexDefs);
  196.     void __fastcall Clear(void);
  197.     TIndexDef* __fastcall FindIndexForFields(const System::AnsiString Fields);
  198.     int __fastcall IndexOf(const System::AnsiString Name);
  199.     void __fastcall Update(void);
  200.     __property int Count = {read=GetCount, nodefault};
  201.     __property TIndexDef* Items[int Index] = {read=GetItem/*, default*/};
  202. };
  203.  
  204. class __declspec(pascalimplementation) TIndexDef : public System::TObject
  205. {
  206.     typedef System::TObject inherited;
  207.     
  208. private:
  209.     TIndexDefs* FOwner;
  210.     System::AnsiString FSource;
  211.     System::AnsiString FName;
  212.     System::AnsiString FFields;
  213.     TIndexOptions FOptions;
  214.     System::AnsiString __fastcall getExpression(void);
  215.     System::AnsiString __fastcall GetFields(void);
  216.     
  217. public:
  218.     __fastcall TIndexDef(TIndexDefs* Owner, const System::AnsiString Name, const System::AnsiString Fields
  219.         , TIndexOptions Options);
  220.     __fastcall virtual ~TIndexDef(void);
  221.     __property System::AnsiString Expression = {read=getExpression, nodefault};
  222.     __property System::AnsiString Fields = {read=GetFields, nodefault};
  223.     __property System::AnsiString Name = {read=FName, nodefault};
  224.     __property TIndexOptions Options = {read=FOptions, nodefault};
  225.     __property System::AnsiString Source = {read=FSource, nodefault};
  226. };
  227.  
  228. class __declspec(delphiclass) TIndexFiles;
  229. class __declspec(pascalimplementation) TIndexFiles : public Classes::TStringList
  230. {
  231.     typedef Classes::TStringList inherited;
  232.     
  233. private:
  234.     TTable* FOwner;
  235.     
  236. public:
  237.     __fastcall TIndexFiles(TTable* AOwner);
  238.     virtual int __fastcall Add(const System::AnsiString S);
  239.     virtual void __fastcall Clear(void);
  240.     virtual void __fastcall Delete(int Index);
  241.     virtual void __fastcall Insert(int Index, const System::AnsiString S);
  242. public:
  243.     /* TStringList.Destroy */ __fastcall virtual ~TIndexFiles(void) { }
  244.     
  245. };
  246.  
  247. class __declspec(delphiclass) TBatchMove;
  248. class __declspec(pascalimplementation) TBatchMove : public Classes::TComponent
  249. {
  250.     typedef Classes::TComponent inherited;
  251.     
  252. private:
  253.     TTable* FDestination;
  254.     Db::TDataSet* FSource;
  255.     TBatchMode FMode;
  256.     bool FAbortOnKeyViol;
  257.     bool FAbortOnProblem;
  258.     bool FTransliterate;
  259.     long FRecordCount;
  260.     long FMovedCount;
  261.     long FKeyViolCount;
  262.     long FProblemCount;
  263.     long FChangedCount;
  264.     Classes::TStrings* FMappings;
  265.     System::AnsiString FKeyViolTableName;
  266.     System::AnsiString FProblemTableName;
  267.     System::AnsiString FChangedTableName;
  268.     int FCommitCount;
  269.     char * __fastcall ConvertName(const System::AnsiString Name, char * Buffer);
  270.     void __fastcall SetDesination(TTable* Value);
  271.     void __fastcall SetMappings(Classes::TStrings* Value);
  272.     void __fastcall SetSource(Db::TDataSet* Value);
  273.     
  274. protected:
  275.     virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
  276.         );
  277.     
  278. public:
  279.     __fastcall virtual TBatchMove(Classes::TComponent* AOwner);
  280.     __fastcall virtual ~TBatchMove(void);
  281.     void __fastcall Execute(void);
  282.     __property long ChangedCount = {read=FChangedCount, nodefault};
  283.     __property long KeyViolCount = {read=FKeyViolCount, nodefault};
  284.     __property long MovedCount = {read=FMovedCount, nodefault};
  285.     __property long ProblemCount = {read=FProblemCount, nodefault};
  286.     
  287. __published:
  288.     __property bool AbortOnKeyViol = {read=FAbortOnKeyViol, write=FAbortOnKeyViol, default=1};
  289.     __property bool AbortOnProblem = {read=FAbortOnProblem, write=FAbortOnProblem, default=1};
  290.     __property int CommitCount = {read=FCommitCount, write=FCommitCount, default=0};
  291.     __property System::AnsiString ChangedTableName = {read=FChangedTableName, write=FChangedTableName, 
  292.         nodefault};
  293.     __property TTable* Destination = {read=FDestination, write=FDestination, nodefault};
  294.     __property System::AnsiString KeyViolTableName = {read=FKeyViolTableName, write=FKeyViolTableName, 
  295.         nodefault};
  296.     __property Classes::TStrings* Mappings = {read=FMappings, write=SetMappings, nodefault};
  297.     __property TBatchMode Mode = {read=FMode, write=FMode, default=0};
  298.     __property System::AnsiString ProblemTableName = {read=FProblemTableName, write=FProblemTableName, 
  299.         nodefault};
  300.     __property long RecordCount = {read=FRecordCount, write=FRecordCount, default=0};
  301.     __property Db::TDataSet* Source = {read=FSource, write=SetSource, nodefault};
  302.     __property bool Transliterate = {read=FTransliterate, write=FTransliterate, default=1};
  303. };
  304.  
  305. enum TParamType { ptUnknown, ptInput, ptOutput, ptInputOutput, ptResult };
  306.  
  307. class __declspec(delphiclass) TParam;
  308. class __declspec(delphiclass) TParams;
  309. class __declspec(pascalimplementation) TParams : public Classes::TPersistent
  310. {
  311.     typedef Classes::TPersistent inherited;
  312.     
  313. private:
  314.     Classes::TList* FItems;
  315.     TParam* __fastcall GetParam(Word Index);
  316.     System::Variant __fastcall GetParamValue(const System::AnsiString ParamName);
  317.     Word __fastcall GetVersion(void);
  318.     void __fastcall ReadBinaryData(Classes::TStream* Stream);
  319.     void __fastcall SetParamValue(const System::AnsiString ParamName, const System::Variant &Value);
  320.     void __fastcall WriteBinaryData(Classes::TStream* Stream);
  321.     
  322. protected:
  323.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  324.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  325.     
  326. public:
  327.     __fastcall virtual TParams(void);
  328.     __fastcall virtual ~TParams(void);
  329.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  330.     void __fastcall AssignValues(TParams* Value);
  331.     void __fastcall AddParam(TParam* Value);
  332.     void __fastcall RemoveParam(TParam* Value);
  333.     TParam* __fastcall CreateParam(Db::TFieldType FldType, const System::AnsiString ParamName, TParamType 
  334.         ParamType);
  335.     int __fastcall Count(void);
  336.     void __fastcall Clear(void);
  337.     void __fastcall GetParamList(Classes::TList* List, const System::AnsiString ParamNames);
  338.     bool __fastcall IsEqual(TParams* Value);
  339.     TParam* __fastcall ParamByName(const System::AnsiString Value);
  340.     __property TParam* Items[Word Index] = {read=GetParam/*, default*/};
  341.     __property System::Variant ParamValues[System::AnsiString ParamName] = {read=GetParamValue, write=SetParamValue
  342.         };
  343. };
  344.  
  345. class __declspec(pascalimplementation) TParam : public System::TObject
  346. {
  347.     typedef System::TObject inherited;
  348.     
  349. private:
  350.     TParams* FParamList;
  351.     System::Variant FData;
  352.     System::AnsiString FName;
  353.     TFieldType FDataType;
  354.     bool FNull;
  355.     bool FBound;
  356.     TParamType FParamType;
  357.     void __fastcall AccessError(void);
  358.     void __fastcall InitValue(void);
  359.     
  360. protected:
  361.     System::Currency __fastcall GetAsBCD(void);
  362.     bool __fastcall GetAsBoolean(void);
  363.     System::TDateTime __fastcall GetAsDateTime(void);
  364.     double __fastcall GetAsFloat(void);
  365.     long __fastcall GetAsInteger(void);
  366.     System::AnsiString __fastcall GetAsString(void);
  367.     System::Variant __fastcall GetAsVariant(void);
  368.     bool __fastcall IsEqual(TParam* Value);
  369.     void __fastcall SetAsBCD(System::Currency Value);
  370.     void __fastcall SetAsBoolean(bool Value);
  371.     void __fastcall SetAsCurrency(double Value);
  372.     void __fastcall SetAsDate(System::TDateTime Value);
  373.     void __fastcall SetAsDateTime(System::TDateTime Value);
  374.     void __fastcall SetAsFloat(double Value);
  375.     void __fastcall SetAsInteger(long Value);
  376.     void __fastcall SetAsString(const System::AnsiString Value);
  377.     void __fastcall SetAsSmallInt(long Value);
  378.     void __fastcall SetAsTime(System::TDateTime Value);
  379.     void __fastcall SetAsVariant(const System::Variant &Value);
  380.     void __fastcall SetAsWord(long Value);
  381.     void __fastcall SetDataType(Db::TFieldType Value);
  382.     void __fastcall SetText(const System::AnsiString Value);
  383.     
  384. public:
  385.     __fastcall TParam(TParams* AParamList, TParamType AParamType);
  386.     __fastcall virtual ~TParam(void);
  387.     void __fastcall Assign(TParam* Param);
  388.     void __fastcall AssignField(Db::TField* Field);
  389.     void __fastcall AssignFieldValue(Db::TField* Field, const System::Variant &Value);
  390.     void __fastcall Clear(void);
  391.     void __fastcall GetData(void * Buffer);
  392.     Word __fastcall GetDataSize(void);
  393.     void __fastcall SetData(void * Buffer);
  394.     __property System::Currency AsBCD = {read=GetAsBCD, write=SetAsBCD};
  395.     __property bool AsBoolean = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
  396.     __property double AsCurrency = {read=GetAsFloat, write=SetAsCurrency};
  397.     __property System::TDateTime AsDate = {read=GetAsDateTime, write=SetAsDate};
  398.     __property System::TDateTime AsDateTime = {read=GetAsDateTime, write=SetAsDateTime};
  399.     __property double AsFloat = {read=GetAsFloat, write=SetAsFloat};
  400.     __property long AsInteger = {read=GetAsInteger, write=SetAsInteger, nodefault};
  401.     __property long AsSmallInt = {read=GetAsInteger, write=SetAsSmallInt, nodefault};
  402.     __property System::AnsiString AsString = {read=GetAsString, write=SetAsString, nodefault};
  403.     __property System::TDateTime AsTime = {read=GetAsDateTime, write=SetAsTime};
  404.     __property long AsWord = {read=GetAsInteger, write=SetAsWord, nodefault};
  405.     __property bool Bound = {read=FBound, write=FBound, nodefault};
  406.     __property Db::TFieldType DataType = {read=FDataType, write=SetDataType, nodefault};
  407.     __property bool IsNull = {read=FNull, nodefault};
  408.     __property System::AnsiString Name = {read=FName, write=FName, nodefault};
  409.     __property TParamType ParamType = {read=FParamType, write=FParamType, nodefault};
  410.     __property System::AnsiString Text = {read=GetAsString, write=SetText, nodefault};
  411.     __property System::Variant Value = {read=GetAsVariant, write=SetAsVariant};
  412. };
  413.  
  414. struct TServerDesc;
  415. typedef TServerDesc *PServerDesc;
  416.  
  417. #pragma pack(push, 1)
  418. struct TServerDesc
  419. {
  420.     System::SmallString<64>  ParamName;
  421.     TFieldType BindType;
  422. } ;
  423. #pragma pack(pop)
  424.  
  425. enum TParamBindMode { pbByName, pbByNumber };
  426.  
  427. class __declspec(delphiclass) TStoredProc;
  428. class __declspec(pascalimplementation) TStoredProc : public Db::TDBDataSet
  429. {
  430.     typedef Db::TDBDataSet inherited;
  431.     
  432. private:
  433.     Bde::_hDBIObj *FStmtHandle;
  434.     System::AnsiString FProcName;
  435.     TParams* FParams;
  436.     char *FParamDesc;
  437.     char *FRecordBuffer;
  438.     Word FOverLoad;
  439.     bool FPrepared;
  440.     bool FQueryMode;
  441.     char *FServerDescs;
  442.     TParamBindMode FBindMode;
  443.     void __fastcall BindParams(void);
  444.     bool __fastcall CheckServerParams(void);
  445.     Bde::hDBICur __fastcall CreateCursor(bool GenHandle);
  446.     void __fastcall CreateParamDesc(void);
  447.     void __fastcall FreeStatement(void);
  448.     Bde::hDBICur __fastcall GetCursor(bool GenHandle);
  449.     void __fastcall PrepareProc(void);
  450.     void __fastcall SetParamsList(TParams* Value);
  451.     void __fastcall SetServerParams(void);
  452.     
  453. protected:
  454.     virtual Bde::hDBICur __fastcall CreateHandle(void);
  455.     virtual void __fastcall Disconnect(void);
  456.     Word __fastcall GetParamsCount(void);
  457.     virtual void __fastcall SetDBFlag(int Flag, bool Value);
  458.     void __fastcall SetOverLoad(Word Value);
  459.     void __fastcall SetProcName(const System::AnsiString Value);
  460.     void __fastcall SetPrepared(bool Value);
  461.     void __fastcall SetPrepare(bool Value);
  462.     
  463. public:
  464.     __fastcall virtual TStoredProc(Classes::TComponent* AOwner);
  465.     __fastcall virtual ~TStoredProc(void);
  466.     void __fastcall CopyParams(TParams* Value);
  467.     bool __fastcall DescriptionsAvailable(void);
  468.     void __fastcall ExecProc(void);
  469.     TParam* __fastcall ParamByName(const System::AnsiString Value);
  470.     void __fastcall Prepare(void);
  471.     void __fastcall GetResults(void);
  472.     void __fastcall UnPrepare(void);
  473.     __property Word ParamCount = {read=GetParamsCount, nodefault};
  474.     __property Bde::hDBIStmt StmtHandle = {read=FStmtHandle, nodefault};
  475.     __property bool Prepared = {read=FPrepared, write=SetPrepare, nodefault};
  476.     
  477. __published:
  478.     __property System::AnsiString StoredProcName = {read=FProcName, write=SetProcName, nodefault};
  479.     __property Word Overload = {read=FOverLoad, write=SetOverLoad, default=0};
  480.     __property TParams* Params = {read=FParams, write=SetParamsList, nodefault};
  481.     __property TParamBindMode ParamBindMode = {read=FBindMode, write=FBindMode, default=0};
  482.     __property UpdateObject ;
  483. };
  484.  
  485. class __declspec(delphiclass) TQuery;
  486. class __declspec(pascalimplementation) TQuery : public Db::TDBDataSet
  487. {
  488.     typedef Db::TDBDataSet inherited;
  489.     
  490. private:
  491.     Bde::_hDBIObj *FStmtHandle;
  492.     Classes::TStrings* FSQL;
  493.     bool FPrepared;
  494.     TParams* FParams;
  495.     System::AnsiString FText;
  496.     Db::TDataLink* FDataLink;
  497.     bool FLocal;
  498.     int FRowsAffected;
  499.     bool FUniDirectional;
  500.     bool FRequestLive;
  501.     char *FSQLBinary;
  502.     bool FConstrained;
  503.     bool FParamCheck;
  504.     Bde::hDBICur __fastcall CreateCursor(bool GenHandle);
  505.     void __fastcall CreateParams(TParams* List, char * const Value);
  506.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  507.     void __fastcall FreeStatement(void);
  508.     Bde::hDBICur __fastcall GetQueryCursor(bool GenHandle);
  509.     void __fastcall GetStatementHandle(char * SQLText);
  510.     char * __fastcall GetSQLText(void);
  511.     int __fastcall GetRowsAffected(void);
  512.     void __fastcall PrepareSQL(char * Value);
  513.     void __fastcall QueryChanged(System::TObject* Sender);
  514.     void __fastcall ReadBinaryData(Classes::TStream* Stream);
  515.     void __fastcall RefreshParams(void);
  516.     void __fastcall SetDataSource(Db::TDataSource* Value);
  517.     void __fastcall SetQuery(Classes::TStrings* Value);
  518.     void __fastcall SetParamsList(TParams* Value);
  519.     void __fastcall SetParams(void);
  520.     void __fastcall SetParamsFromCursor(void);
  521.     void __fastcall SetPrepared(bool Value);
  522.     void __fastcall SetPrepare(bool Value);
  523.     void __fastcall WriteBinaryData(Classes::TStream* Stream);
  524.     
  525. protected:
  526.     virtual Bde::hDBICur __fastcall CreateHandle(void);
  527.     virtual void __fastcall Disconnect(void);
  528.     virtual Db::TDataSource* __fastcall GetDataSource(void);
  529.     Word __fastcall GetParamsCount(void);
  530.     virtual void __fastcall SetDBFlag(int Flag, bool Value);
  531.     
  532. public:
  533.     __fastcall virtual TQuery(Classes::TComponent* AOwner);
  534.     __fastcall virtual ~TQuery(void);
  535.     void __fastcall ExecSQL(void);
  536.     TParam* __fastcall ParamByName(const System::AnsiString Value);
  537.     void __fastcall Prepare(void);
  538.     void __fastcall UnPrepare(void);
  539.     __property bool Prepared = {read=FPrepared, write=SetPrepare, nodefault};
  540.     __property Word ParamCount = {read=GetParamsCount, nodefault};
  541.     __property bool Local = {read=FLocal, nodefault};
  542.     __property Bde::hDBIStmt StmtHandle = {read=FStmtHandle, nodefault};
  543.     __property System::AnsiString Text = {read=FText, nodefault};
  544.     __property int RowsAffected = {read=GetRowsAffected, nodefault};
  545.     __property char * SQLBinary = {read=FSQLBinary, write=FSQLBinary, nodefault};
  546.     
  547. __published:
  548.     __property bool Constrained = {read=FConstrained, write=FConstrained, default=0};
  549.     __property Db::TDataSource* DataSource = {read=GetDataSource, write=SetDataSource, nodefault};
  550.     __property TParams* Params = {read=FParams, write=SetParamsList, nodefault};
  551.     __property bool ParamCheck = {read=FParamCheck, write=FParamCheck, default=1};
  552.     __property bool RequestLive = {read=FRequestLive, write=FRequestLive, default=0};
  553.     __property Classes::TStrings* SQL = {read=FSQL, write=SetQuery, nodefault};
  554.     __property bool UniDirectional = {read=FUniDirectional, write=FUniDirectional, default=0};
  555.     __property UpdateMode ;
  556.     __property UpdateObject ;
  557. };
  558.  
  559. class __declspec(delphiclass) TUpdateSQL;
  560. class __declspec(pascalimplementation) TUpdateSQL : public Db::TDataSetUpdateObject
  561. {
  562.     typedef Db::TDataSetUpdateObject inherited;
  563.     
  564. private:
  565.     Db::TDataSet* FDataSet;
  566.     TQuery* FQueries[3];
  567.     Classes::TStrings* FSQLText[3];
  568.     TQuery* __fastcall GetQuery(Db::TUpdateKind UpdateKind);
  569.     Classes::TStrings* __fastcall GetSQL(Db::TUpdateKind UpdateKind);
  570.     Classes::TStrings* __fastcall GetSQLIndex(int Index);
  571.     void __fastcall SetSQL(Db::TUpdateKind UpdateKind, Classes::TStrings* Value);
  572.     void __fastcall SetSQLIndex(int Index, Classes::TStrings* Value);
  573.     
  574. protected:
  575.     virtual Db::TDataSet* __fastcall GetDataSet(void);
  576.     virtual void __fastcall SetDataSet(Db::TDataSet* ADataSet);
  577.     
  578. public:
  579.     __fastcall virtual TUpdateSQL(Classes::TComponent* AOwner);
  580.     __fastcall virtual ~TUpdateSQL(void);
  581.     virtual void __fastcall Apply(Db::TUpdateKind UpdateKind);
  582.     void __fastcall ExecSQL(Db::TUpdateKind UpdateKind);
  583.     void __fastcall SetParams(Db::TUpdateKind UpdateKind);
  584.     __property DataSet ;
  585.     __property TQuery* Query[Db::TUpdateKind UpdateKind] = {read=GetQuery};
  586.     __property Classes::TStrings* SQL[Db::TUpdateKind UpdateKind] = {read=GetSQL, write=SetSQL};
  587.     
  588. __published:
  589.     __property Classes::TStrings* ModifySQL = {read=GetSQLIndex, write=SetSQLIndex, index=0, nodefault}
  590.         ;
  591.     __property Classes::TStrings* InsertSQL = {read=GetSQLIndex, write=SetSQLIndex, index=1, nodefault}
  592.         ;
  593.     __property Classes::TStrings* DeleteSQL = {read=GetSQLIndex, write=SetSQLIndex, index=2, nodefault}
  594.         ;
  595. };
  596.  
  597. class __declspec(delphiclass) TStringField;
  598. class __declspec(pascalimplementation) TStringField : public Db::TField
  599. {
  600.     typedef Db::TField inherited;
  601.     
  602. private:
  603.     bool FTransliterate;
  604.     Byte FReserved;
  605.     
  606. protected:
  607.     virtual bool __fastcall GetAsBoolean(void);
  608.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  609.     virtual double __fastcall GetAsFloat(void);
  610.     virtual long __fastcall GetAsInteger(void);
  611.     virtual System::AnsiString __fastcall GetAsString(void);
  612.     virtual System::Variant __fastcall GetAsVariant(void);
  613.     virtual int __fastcall GetDefaultWidth(void);
  614.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  615.     bool __fastcall GetValue( System::AnsiString &Value);
  616.     virtual void __fastcall SetAsBoolean(bool Value);
  617.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  618.     virtual void __fastcall SetAsFloat(double Value);
  619.     virtual void __fastcall SetAsInteger(long Value);
  620.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  621.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  622.     
  623. public:
  624.     __fastcall virtual TStringField(Classes::TComponent* AOwner);
  625.     __property System::AnsiString Value = {read=GetAsString, write=SetAsString, nodefault};
  626.     
  627. __published:
  628.     __property EditMask ;
  629.     __property Size ;
  630.     __property bool Transliterate = {read=FTransliterate, write=FTransliterate, default=1};
  631. public:
  632.     /* TField.Destroy */ __fastcall virtual ~TStringField(void) { }
  633.     
  634. };
  635.  
  636. class __declspec(delphiclass) TNumericField;
  637. class __declspec(pascalimplementation) TNumericField : public Db::TField
  638. {
  639.     typedef Db::TField inherited;
  640.     
  641. private:
  642.     System::AnsiString FDisplayFormat;
  643.     System::AnsiString FEditFormat;
  644.     void __fastcall RangeError(Extended Value, Extended Min, Extended Max);
  645.     void __fastcall SetDisplayFormat(const System::AnsiString Value);
  646.     void __fastcall SetEditFormat(const System::AnsiString Value);
  647.     
  648. public:
  649.     __fastcall virtual TNumericField(Classes::TComponent* AOwner);
  650.     
  651. __published:
  652.     __property Alignment ;
  653.     __property System::AnsiString DisplayFormat = {read=FDisplayFormat, write=SetDisplayFormat, nodefault
  654.         };
  655.     __property System::AnsiString EditFormat = {read=FEditFormat, write=SetEditFormat, nodefault};
  656. public:
  657.         
  658.     /* TField.Destroy */ __fastcall virtual ~TNumericField(void) { }
  659.     
  660. };
  661.  
  662. class __declspec(delphiclass) TIntegerField;
  663. class __declspec(pascalimplementation) TIntegerField : public TNumericField
  664. {
  665.     typedef TNumericField inherited;
  666.     
  667. private:
  668.     long FMinRange;
  669.     long FMaxRange;
  670.     long FMinValue;
  671.     long FMaxValue;
  672.     void __fastcall CheckRange(long Value, long Min, long Max);
  673.     void __fastcall SetMaxValue(long Value);
  674.     void __fastcall SetMinValue(long Value);
  675.     
  676. protected:
  677.     virtual double __fastcall GetAsFloat(void);
  678.     virtual long __fastcall GetAsInteger(void);
  679.     virtual System::AnsiString __fastcall GetAsString(void);
  680.     virtual System::Variant __fastcall GetAsVariant(void);
  681.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  682.     bool __fastcall GetValue(long &Value);
  683.     virtual void __fastcall SetAsFloat(double Value);
  684.     virtual void __fastcall SetAsInteger(long Value);
  685.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  686.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  687.     
  688. public:
  689.     __fastcall virtual TIntegerField(Classes::TComponent* AOwner);
  690.     virtual bool __fastcall IsValidChar(char Ch);
  691.     __property long Value = {read=GetAsInteger, write=SetAsInteger, nodefault};
  692.     
  693. __published:
  694.     __property long MaxValue = {read=FMaxValue, write=SetMaxValue, default=0};
  695.     __property long MinValue = {read=FMinValue, write=SetMinValue, default=0};
  696. public:
  697.     /* TField.Destroy */ __fastcall virtual ~TIntegerField(void) { }
  698.     
  699. };
  700.  
  701. class __declspec(delphiclass) TSmallintField;
  702. class __declspec(pascalimplementation) TSmallintField : public TIntegerField
  703. {
  704.     typedef TIntegerField inherited;
  705.     
  706. public:
  707.     __fastcall virtual TSmallintField(Classes::TComponent* AOwner);
  708. public:
  709.     /* TField.Destroy */ __fastcall virtual ~TSmallintField(void) { }
  710.     
  711. };
  712.  
  713. class __declspec(delphiclass) TWordField;
  714. class __declspec(pascalimplementation) TWordField : public TIntegerField
  715. {
  716.     typedef TIntegerField inherited;
  717.     
  718. public:
  719.     __fastcall virtual TWordField(Classes::TComponent* AOwner);
  720. public:
  721.     /* TField.Destroy */ __fastcall virtual ~TWordField(void) { }
  722.     
  723. };
  724.  
  725. class __declspec(delphiclass) TAutoIncField;
  726. class __declspec(pascalimplementation) TAutoIncField : public TIntegerField
  727. {
  728.     typedef TIntegerField inherited;
  729.     
  730. public:
  731.     __fastcall virtual TAutoIncField(Classes::TComponent* AOwner);
  732. public:
  733.     /* TField.Destroy */ __fastcall virtual ~TAutoIncField(void) { }
  734.     
  735. };
  736.  
  737. class __declspec(delphiclass) TFloatField;
  738. class __declspec(pascalimplementation) TFloatField : public TNumericField
  739. {
  740.     typedef TNumericField inherited;
  741.     
  742. private:
  743.     bool FCurrency;
  744.     bool FCheckRange;
  745.     int FPrecision;
  746.     double FMinValue;
  747.     double FMaxValue;
  748.     void __fastcall SetCurrency(bool Value);
  749.     void __fastcall SetMaxValue(double Value);
  750.     void __fastcall SetMinValue(double Value);
  751.     void __fastcall SetPrecision(int Value);
  752.     void __fastcall UpdateCheckRange(void);
  753.     
  754. protected:
  755.     virtual double __fastcall GetAsFloat(void);
  756.     virtual long __fastcall GetAsInteger(void);
  757.     virtual System::AnsiString __fastcall GetAsString(void);
  758.     virtual System::Variant __fastcall GetAsVariant(void);
  759.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  760.     virtual void __fastcall SetAsFloat(double Value);
  761.     virtual void __fastcall SetAsInteger(long Value);
  762.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  763.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  764.     
  765. public:
  766.     __fastcall virtual TFloatField(Classes::TComponent* AOwner);
  767.     virtual bool __fastcall IsValidChar(char Ch);
  768.     __property double Value = {read=GetAsFloat, write=SetAsFloat};
  769.     
  770. __published:
  771.     __property bool currency = {read=FCurrency, write=SetCurrency, default=0};
  772.     __property double MaxValue = {read=FMaxValue, write=SetMaxValue};
  773.     __property double MinValue = {read=FMinValue, write=SetMinValue};
  774.     __property int Precision = {read=FPrecision, write=SetPrecision, default=15};
  775. public:
  776.     /* TField.Destroy */ __fastcall virtual ~TFloatField(void) { }
  777.     
  778. };
  779.  
  780. class __declspec(delphiclass) TCurrencyField;
  781. class __declspec(pascalimplementation) TCurrencyField : public TFloatField
  782. {
  783.     typedef TFloatField inherited;
  784.     
  785. public:
  786.     __fastcall virtual TCurrencyField(Classes::TComponent* AOwner);
  787.     
  788. __published:
  789.     __property currency ;
  790. public:
  791.     /* TField.Destroy */ __fastcall virtual ~TCurrencyField(void) { }
  792.     
  793. };
  794.  
  795. class __declspec(delphiclass) TBCDField;
  796. class __declspec(pascalimplementation) TBCDField : public TNumericField
  797. {
  798.     typedef TNumericField inherited;
  799.     
  800. public:
  801.     bool FCurrency;
  802.     bool FCheckRange;
  803.     System::Currency FMinValue;
  804.     System::Currency FMaxValue;
  805.     void __fastcall SetCurrency(bool Value);
  806.     void __fastcall SetMaxValue(System::Currency Value);
  807.     void __fastcall SetMinValue(System::Currency Value);
  808.     void __fastcall UpdateCheckRange(void);
  809.     
  810. protected:
  811.     virtual System::Currency __fastcall GetAsCurrency(void);
  812.     virtual double __fastcall GetAsFloat(void);
  813.     virtual long __fastcall GetAsInteger(void);
  814.     virtual System::AnsiString __fastcall GetAsString(void);
  815.     virtual System::Variant __fastcall GetAsVariant(void);
  816.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  817.     bool __fastcall GetValue(System::Currency &Value);
  818.     virtual void __fastcall SetAsCurrency(System::Currency Value);
  819.     virtual void __fastcall SetAsFloat(double Value);
  820.     virtual void __fastcall SetAsInteger(long Value);
  821.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  822.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  823.     
  824. public:
  825.     __fastcall virtual TBCDField(Classes::TComponent* AOwner);
  826.     virtual bool __fastcall IsValidChar(char Ch);
  827.     __property System::Currency Value = {read=GetAsCurrency, write=SetAsCurrency};
  828.     
  829. __published:
  830.     __property bool currency = {read=FCurrency, write=SetCurrency, default=0};
  831.     __property System::Currency MaxValue = {read=FMaxValue, write=SetMaxValue};
  832.     __property System::Currency MinValue = {read=FMinValue, write=SetMinValue};
  833.     __property Size ;
  834. public:
  835.     /* TField.Destroy */ __fastcall virtual ~TBCDField(void) { }
  836.     
  837. };
  838.  
  839. typedef System::AnsiString DBTables_32[2];
  840.  
  841. class __declspec(delphiclass) TBooleanField;
  842. class __declspec(pascalimplementation) TBooleanField : public Db::TField
  843. {
  844.     typedef Db::TField inherited;
  845.     
  846. private:
  847.     System::AnsiString FDisplayValues;
  848.     System::AnsiString FTextValues[2];
  849.     void __fastcall LoadTextValues(void);
  850.     void __fastcall SetDisplayValues(const System::AnsiString Value);
  851.     
  852. protected:
  853.     virtual bool __fastcall GetAsBoolean(void);
  854.     virtual System::AnsiString __fastcall GetAsString(void);
  855.     virtual System::Variant __fastcall GetAsVariant(void);
  856.     virtual int __fastcall GetDefaultWidth(void);
  857.     virtual void __fastcall SetAsBoolean(bool Value);
  858.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  859.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  860.     
  861. public:
  862.     __fastcall virtual TBooleanField(Classes::TComponent* AOwner);
  863.     __property bool Value = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
  864.     
  865. __published:
  866.     __property System::AnsiString DisplayValues = {read=FDisplayValues, write=SetDisplayValues, nodefault
  867.         };
  868. public:
  869.     /* TField.Destroy */ __fastcall virtual ~TBooleanField(void) { }
  870.     
  871. };
  872.  
  873. class __declspec(delphiclass) TDateTimeField;
  874. class __declspec(pascalimplementation) TDateTimeField : public Db::TField
  875. {
  876.     typedef Db::TField inherited;
  877.     
  878. private:
  879.     System::AnsiString FDisplayFormat;
  880.     bool __fastcall GetValue(System::TDateTime &Value);
  881.     void __fastcall SetDisplayFormat(const System::AnsiString Value);
  882.     
  883. protected:
  884.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  885.     virtual double __fastcall GetAsFloat(void);
  886.     virtual System::AnsiString __fastcall GetAsString(void);
  887.     virtual System::Variant __fastcall GetAsVariant(void);
  888.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  889.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  890.     virtual void __fastcall SetAsFloat(double Value);
  891.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  892.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  893.     
  894. public:
  895.     __fastcall virtual TDateTimeField(Classes::TComponent* AOwner);
  896.     __property System::TDateTime Value = {read=GetAsDateTime, write=SetAsDateTime};
  897.     
  898. __published:
  899.     __property System::AnsiString DisplayFormat = {read=FDisplayFormat, write=SetDisplayFormat, nodefault
  900.         };
  901.     __property EditMask ;
  902. public:
  903.     /* TField.Destroy */ __fastcall virtual ~TDateTimeField(void) { }
  904.     
  905. };
  906.  
  907. class __declspec(delphiclass) TDateField;
  908. class __declspec(pascalimplementation) TDateField : public TDateTimeField
  909. {
  910.     typedef TDateTimeField inherited;
  911.     
  912. public:
  913.     __fastcall virtual TDateField(Classes::TComponent* AOwner);
  914. public:
  915.     /* TField.Destroy */ __fastcall virtual ~TDateField(void) { }
  916.     
  917. };
  918.  
  919. class __declspec(delphiclass) TTimeField;
  920. class __declspec(pascalimplementation) TTimeField : public TDateTimeField
  921. {
  922.     typedef TDateTimeField inherited;
  923.     
  924. public:
  925.     __fastcall virtual TTimeField(Classes::TComponent* AOwner);
  926. public:
  927.     /* TField.Destroy */ __fastcall virtual ~TTimeField(void) { }
  928.     
  929. };
  930.  
  931. class __declspec(delphiclass) TBinaryField;
  932. class __declspec(pascalimplementation) TBinaryField : public Db::TField
  933. {
  934.     typedef Db::TField inherited;
  935.     
  936. protected:
  937.     virtual System::Variant __fastcall GetAsVariant(void);
  938.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  939.     
  940. public:
  941.     __fastcall virtual TBinaryField(Classes::TComponent* AOwner);
  942.     
  943. __published:
  944.     __property Size ;
  945. public:
  946.     /* TField.Destroy */ __fastcall virtual ~TBinaryField(void) { }
  947.     
  948. };
  949.  
  950. class __declspec(delphiclass) TBytesField;
  951. class __declspec(pascalimplementation) TBytesField : public TBinaryField
  952. {
  953.     typedef TBinaryField inherited;
  954.     
  955. public:
  956.     __fastcall virtual TBytesField(Classes::TComponent* AOwner);
  957. public:
  958.     /* TField.Destroy */ __fastcall virtual ~TBytesField(void) { }
  959.     
  960. };
  961.  
  962. class __declspec(delphiclass) TVarBytesField;
  963. class __declspec(pascalimplementation) TVarBytesField : public TBytesField
  964. {
  965.     typedef TBytesField inherited;
  966.     
  967. public:
  968.     __fastcall virtual TVarBytesField(Classes::TComponent* AOwner);
  969. public:
  970.     /* TField.Destroy */ __fastcall virtual ~TVarBytesField(void) { }
  971.     
  972. };
  973.  
  974. typedef TFieldType TBlobType;
  975.  
  976. class __declspec(delphiclass) TBlobField;
  977. class __declspec(pascalimplementation) TBlobField : public Db::TField
  978. {
  979.     typedef Db::TField inherited;
  980.     
  981. private:
  982.     bool FModified;
  983.     bool FTransliterate;
  984.     TBlobType __fastcall GetBlobType(void);
  985.     void __fastcall LoadFromBlob(TBlobField* Blob);
  986.     void __fastcall LoadFromBitmap(Graphics::TBitmap* Bitmap);
  987.     void __fastcall LoadFromStrings(Classes::TStrings* Strings);
  988.     void __fastcall SaveToBitmap(Graphics::TBitmap* Bitmap);
  989.     void __fastcall SaveToStrings(Classes::TStrings* Strings);
  990.     void __fastcall SetBlobType(TBlobType Value);
  991.     
  992. protected:
  993.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  994.     virtual void __fastcall FreeBuffers(void);
  995.     virtual System::AnsiString __fastcall GetAsString(void);
  996.     virtual System::Variant __fastcall GetAsVariant(void);
  997.     virtual void __fastcall GetText( System::AnsiString &Text, bool DisplayText);
  998.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  999.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1000.     __property bool Transliterate = {read=FTransliterate, write=FTransliterate, default=1};
  1001.     
  1002. public:
  1003.     __fastcall virtual TBlobField(Classes::TComponent* AOwner);
  1004.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  1005.     virtual void __fastcall Clear(void);
  1006.     void __fastcall LoadFromFile(const System::AnsiString FileName);
  1007.     void __fastcall LoadFromStream(Classes::TStream* Stream);
  1008.     void __fastcall SaveToFile(const System::AnsiString FileName);
  1009.     void __fastcall SaveToStream(Classes::TStream* Stream);
  1010.     virtual void __fastcall SetFieldType(Db::TFieldType Value);
  1011.     virtual void __fastcall SetText(const System::AnsiString Value);
  1012.     __property System::AnsiString Value = {read=GetAsString, write=SetAsString, nodefault};
  1013.     
  1014. __published:
  1015.     __property TBlobType BlobType = {read=GetBlobType, write=SetBlobType, nodefault};
  1016.     __property Size ;
  1017. public:
  1018.     /* TField.Destroy */ __fastcall virtual ~TBlobField(void) { }
  1019.     
  1020. };
  1021.  
  1022. class __declspec(delphiclass) TMemoField;
  1023. class __declspec(pascalimplementation) TMemoField : public TBlobField
  1024. {
  1025.     typedef TBlobField inherited;
  1026.     
  1027. public:
  1028.     __fastcall virtual TMemoField(Classes::TComponent* AOwner);
  1029.     
  1030. __published:
  1031.     __property Transliterate ;
  1032. public:
  1033.     /* TField.Destroy */ __fastcall virtual ~TMemoField(void) { }
  1034.     
  1035. };
  1036.  
  1037. class __declspec(delphiclass) TGraphicField;
  1038. class __declspec(pascalimplementation) TGraphicField : public TBlobField
  1039. {
  1040.     typedef TBlobField inherited;
  1041.     
  1042. public:
  1043.     __fastcall virtual TGraphicField(Classes::TComponent* AOwner);
  1044. public:
  1045.     /* TField.Destroy */ __fastcall virtual ~TGraphicField(void) { }
  1046.     
  1047. };
  1048.  
  1049. enum TBlobStreamMode { bmRead, bmWrite, bmReadWrite };
  1050.  
  1051. class __declspec(delphiclass) TBlobStream;
  1052. class __declspec(pascalimplementation) TBlobStream : public Classes::TStream
  1053. {
  1054.     typedef Classes::TStream inherited;
  1055.     
  1056. private:
  1057.     TBlobField* FField;
  1058.     Db::TDataSet* FDataSet;
  1059.     char *FRecord;
  1060.     char *FBuffer;
  1061.     int FFieldNo;
  1062.     bool FOpened;
  1063.     bool FModified;
  1064.     long FPosition;
  1065.     long __fastcall GetBlobSize(void);
  1066.     
  1067. public:
  1068.     __fastcall TBlobStream(TBlobField* Field, TBlobStreamMode Mode);
  1069.     __fastcall virtual ~TBlobStream(void);
  1070.     virtual long __fastcall Read(void *Buffer, long Count);
  1071.     virtual long __fastcall Write(const void *Buffer, long Count);
  1072.     virtual long __fastcall Seek(long Offset, Word Origin);
  1073.     void __fastcall Truncate(void);
  1074. };
  1075.  
  1076. class __declspec(delphiclass) TFieldDataLink;
  1077. class __declspec(pascalimplementation) TFieldDataLink : public Db::TDataLink
  1078. {
  1079.     typedef Db::TDataLink inherited;
  1080.     
  1081. private:
  1082.     Db::TField* FField;
  1083.     System::AnsiString FFieldName;
  1084.     Controls::TWinControl* FControl;
  1085.     bool FEditing;
  1086.     bool FModified;
  1087.     Classes::TNotifyEvent FOnDataChange;
  1088.     Classes::TNotifyEvent FOnEditingChange;
  1089.     Classes::TNotifyEvent FOnUpdateData;
  1090.     Classes::TNotifyEvent FOnActiveChange;
  1091.     bool __fastcall GetCanModify(void);
  1092.     HIDESBASE void __fastcall SetEditing(bool Value);
  1093.     void __fastcall SetField(Db::TField* Value);
  1094.     void __fastcall SetFieldName(const System::AnsiString Value);
  1095.     void __fastcall UpdateField(void);
  1096.     
  1097. protected:
  1098.     virtual void __fastcall ActiveChanged(void);
  1099.     virtual void __fastcall EditingChanged(void);
  1100.     virtual void __fastcall FocusControl(Db::TFieldRef Field);
  1101.     virtual void __fastcall LayoutChanged(void);
  1102.     virtual void __fastcall RecordChanged(Db::TField* Field);
  1103.     virtual void __fastcall UpdateData(void);
  1104.     
  1105. public:
  1106.     HIDESBASE bool __fastcall Edit(void);
  1107.     void __fastcall Modified(void);
  1108.     void __fastcall Reset(void);
  1109.     __property bool CanModify = {read=GetCanModify, nodefault};
  1110.     __property Controls::TWinControl* Control = {read=FControl, write=FControl, nodefault};
  1111.     __property bool Editing = {read=FEditing, nodefault};
  1112.     __property Db::TField* Field = {read=FField, nodefault};
  1113.     __property System::AnsiString FieldName = {read=FFieldName, write=SetFieldName, nodefault};
  1114.     __property Classes::TNotifyEvent OnDataChange = {read=FOnDataChange, write=FOnDataChange};
  1115.     __property Classes::TNotifyEvent OnEditingChange = {read=FOnEditingChange, write=FOnEditingChange};
  1116.         
  1117.     __property Classes::TNotifyEvent OnUpdateData = {read=FOnUpdateData, write=FOnUpdateData};
  1118.     __property Classes::TNotifyEvent OnActiveChange = {read=FOnActiveChange, write=FOnActiveChange};
  1119. public:
  1120.         
  1121.     /* TDataLink.Create */ __fastcall TFieldDataLink(void) : Db::TDataLink() { }
  1122.     /* TDataLink.Destroy */ __fastcall virtual ~TFieldDataLink(void) { }
  1123.     
  1124. };
  1125.  
  1126. //-- var, const, procedure ---------------------------------------------------
  1127. extern bool __fastcall BCDToCurr(const Bde::FMTBcd &BCD, System::Currency &Curr);
  1128. extern bool __fastcall CurrToBCD(System::Currency Curr, Bde::FMTBcd &BCD, int Precision, int Decimals
  1129.     );
  1130. //-- template instantiations -------------------------------------------------
  1131. template class SmallString<64> ;
  1132. template class TIndexOptions ;
  1133.  
  1134. }    /* namespace Dbtables */
  1135.  
  1136. #pragma warn .par
  1137. #pragma warn .hid 
  1138. #pragma warn .inl
  1139.  
  1140. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  1141. using namespace Dbtables;
  1142. #endif
  1143. //-- end unit ----------------------------------------------------------------
  1144. #endif    // DBTables
  1145.